packages/query-core/src/utils.ts (1)

168-175: Use resolveOption here for consistency (duplicate of earlier feedback).

This is the same “value or updater function” pattern. Reusing resolveOption or the local isFunctionVariant keeps the file consistent and DRY.

Apply this diff:

 export function functionalUpdate<TInput, TOutput>(
   updater: Updater<TInput, TOutput>,
   input: TInput,
 ): TOutput {
-  return typeof updater === 'function'
-    ? (updater as (_: TInput) => TOutput)(input)
-    : updater
+  return isFunctionVariant<Updater<TInput, TOutput>, [TInput]>(updater)
+    ? (updater as (_: TInput) => TOutput)(input)
+    : (updater as TOutput)
 }

Note: This still shares the same ambiguity if TOutput is itself a function. If you adopt NonFunctionGuard for resolveOption, consider mirroring that here for true parity.

packages/query-core/src/query.ts (1)

692-698: Consider adding type safety for InitialDataFunction pattern

While the resolveOption utility handles the function-or-value pattern generically, the removal of the InitialDataFunction type means we lose some type safety. The current implementation will accept any function, not just zero-argument functions.

Consider adding a type constraint to ensure initialData and initialDataUpdatedAt functions don't accidentally accept parameters:

-  const data = resolveOption(options.initialData)
+  const data = resolveOption(options.initialData as TData | (() => TData | undefined))
 
   const hasData = data !== undefined
 
   const initialDataUpdatedAt = hasData
-    ? resolveOption(options.initialDataUpdatedAt)
+    ? resolveOption(options.initialDataUpdatedAt as number | (() => number | undefined) | undefined)
     : 0

packages/query-core/src/utils.ts (1)

80-116: Tighten the type guard: return a function typed to T, not any.

Returning any from the predicate unnecessarily weakens type inference in downstream callers (including resolveOption). Have the predicate assert (...args: TArgs) => T and prefer unknown[] over Array<any>.

Apply this diff:

-function isFunctionVariant<T, TArgs extends Array<any> = []>(
-  value: T | ((...args: TArgs) => any),
-): value is (...args: TArgs) => any {
+function isFunctionVariant<T, TArgs extends unknown[] = []>(
+  value: T | ((...args: TArgs) => T),
+): value is (...args: TArgs) => T {
   return typeof value === 'function'
 }

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

packages/query-core/src/utils.ts (2)

172-172: Addressed prior note: functionalUpdate now uses resolveOption.

This replaces the typeof check with the new utility as requested in earlier review comments.

---

117-166: Critical: resolveOption will eagerly invoke function-typed values when T itself is a function (ambiguous semantics).

If T is a function type, direct function “values” will be treated as the callback variant and invoked. This is the ambiguity that the former NonFunctionGuard prevented and can lead to runtime bugs and surprising side-effects. This also aligns with prior review feedback.

Fix by constraining T to non-function values for the direct-value branch and defaulting TArgs to unknown[] to improve inference:

-export function resolveOption<T, TArgs extends Array<any>>(
-  value: T | ((...args: TArgs) => T),
-  ...args: TArgs
-): T {
-  return isFunctionVariant(value) ? value(...args) : value
-}
+export function resolveOption<T, TArgs extends unknown[] = []>(
+  value: NonFunctionGuard<T> | ((...args: TArgs) => T),
+  ...args: TArgs
+): T {
+  return typeof value === 'function'
+    ? (value as (...args: TArgs) => T)(...args)
+    : (value as T)
+}

Also add the missing utility type and import:

• In types.ts (exported somewhere central):

// Add this near existing utility types
export type NonFunctionGuard<T> = T extends Function ? never : T

• Update the import in this file to pull it in (adjust your existing types import):

import type {
  DefaultError,
  FetchStatus,
  MutationKey,
  MutationStatus,
  QueryFunction,
  QueryKey,
  QueryOptions,
+ NonFunctionGuard,
} from './types'

If you need an escape hatch for cases where function-shaped T must be allowed as a direct value, introduce a second API, e.g. resolveOptionAllowFunction, and use it only where intended.

Verification script (locates call sites and checks for the guard’s presence):

#!/bin/bash
# 1) Confirm the NonFunctionGuard type exists (or not).
rg -nP --type=ts '\btype\s+NonFunctionGuard\b|export\s+type\s+NonFunctionGuard\b' -C2

# 2) List all resolveOption call sites with context to audit ambiguous usages.
rg -nP --type=ts '\bresolveOption\s*\(' -C3

# 3) Heuristic: show spots where the resolved T could plausibly be a function-typed value
#    (look for option names that might carry function-shaped data).
rg -nP --type=ts -C2 '(initialData|placeholderData|notifyOnChangeProps|refetchInterval|retryDelay)\b'

packages/query-core/src/utils.ts (1)

80-116: Prefer unknown[] over Array and avoid leaking any from the guard.

Tighten the generics to unknown[] and use unknown instead of any for the guard’s return type. This improves type safety without changing behavior.

Apply:

-function isFunctionVariant<T, TArgs extends Array<any> = []>(
-  value: T | ((...args: TArgs) => any),
-): value is (...args: TArgs) => any {
+function isFunctionVariant<T, TArgs extends unknown[] = []>(
+  value: T | ((...args: TArgs) => unknown),
+): value is (...args: TArgs) => unknown {
   return typeof value === 'function'
 }

Optional: if you foresee external usage for narrowing, consider exporting this guard. Otherwise keeping it internal is fine.

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.